﻿using System;
using System.Data;
using System.Data.SqlClient;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace tracker.Models
{
    public class ErpCatalogueBaseBL : IDisposable
    {
        public void Dispose() { }

        #region Catalogue Procedure

        private const string PARAM_PRIMARY_KEY = "@pk";
        private const string PARAM_FOREIGN_KEY = "@fk";
        public const string FIELD_FROMDATE = "FromDate";
        public const string FIELD_TODATE = "ToDate";
        public const string STORE_NEWID = "ACT_procGetNewID";
        public const string FIELD_TABLE = "Table";
        public const string FIELD_PRIMARYKEY = "PrimaryKey";
        public const string FIELD_CURRENTDATE = "CurrentDate";

        #region Select Procedure

        public static string GetNewID(string FormKey, string _strPrimaryKey, string _strTable)
        {
            DataSet ds;
            string _month = DateTime.Now.Month < 10 ? "0" + DateTime.Now.Month.ToString() : DateTime.Now.Month.ToString();
            string _day = DateTime.Now.Day < 10 ? "0" + DateTime.Now.Day.ToString() : DateTime.Now.Day.ToString();
            string strCurrentDate = (DateTime.Now.Year.ToString()).Substring(2, 2) + _month + _day;
            ds = SelectAllWithParameter(STORE_NEWID, new string[] { FIELD_CURRENTDATE, FIELD_PRIMARYKEY, FIELD_TABLE },
                                                    new object[] { strCurrentDate, _strPrimaryKey, _strTable });
            if (ds.Tables[0].Rows.Count == 0)
                return FormKey + strCurrentDate + "001";
            else if (int.Parse(ds.Tables[0].Rows[0][0].ToString()) < 100)
                return FormKey + strCurrentDate + "00" + ds.Tables[0].Rows[0][0].ToString();
            else if (int.Parse(ds.Tables[0].Rows[0][0].ToString()) < 10)
                return FormKey + strCurrentDate + "0" + ds.Tables[0].Rows[0][0].ToString();
            else
                return FormKey + strCurrentDate + ds.Tables[0].Rows[0][0].ToString();
        }
        /// <summary>
        /// Hàm này lấy tất cả các ROW thuộc về 1 TABLE nào đó
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <returns>DataSet</returns>
        protected static DataSet SelectAll(string strStoreName)
        {
            DataSet ds = new DataSet();
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    ds = objConn.Connection.runSQLQuery(strStoreName, CommandType.StoredProcedure);
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        ds.DataSetName = "Exception:" + ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        ds.DataSetName = "Exception:" + ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return ds;
        }

        /// <summary>
        /// Hàm này lấy tất cả các field dữ liệu của một ROW nào đó
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <param name="strPrimaryKey">Primary Key Value</param>
        /// <returns>DataSet</returns>
        protected static DataSet SelectOne(string strStoreName, string strPrimaryKeyValue)
        {
            DataSet ds = new DataSet();
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    ds = objConn.Connection.runDynamicSqlQuery(strStoreName, new string[] { PARAM_PRIMARY_KEY }, new object[] { strPrimaryKeyValue }, CommandType.StoredProcedure);
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        ds.DataSetName = "Exception:" + ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        ds.DataSetName = "Exception:" + ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return ds;
        }

        /// <summary>
        /// Hàm này lấy tất cả các field dữ liệu của một ROW nào đó
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <param name="strPrimaryKey">Primary Key Value</param>
        /// <returns>DataSet</returns>
        protected static DataSet SelectOne(string strStoreName, string[] arrParamName, object[] arrParamValue)
        {
            DataSet ds = new DataSet();
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    ds = objConn.Connection.runDynamicSqlQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure);
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        ds.DataSetName = "Exception:" + ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        ds.DataSetName = "Exception:" + ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return ds;
        }

        /// <summary>
        /// Hàm này lấy tất cả các ROW có khóa ngoại liên kết đến Table hiện tại
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <param name="strForeignKey">Foreign Key Value</param>
        /// <returns>DataSet</returns>
        protected static DataSet SelectAllWithParameter(string strStoreName, string strForeignKeyValue)
        {
            DataSet ds = new DataSet();
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    ds = objConn.Connection.runDynamicSqlQuery(strStoreName, new string[] { PARAM_FOREIGN_KEY }, new object[] { strForeignKeyValue }, CommandType.StoredProcedure);
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        ds.DataSetName = "Exception:" + ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        ds.DataSetName = "Exception:" + ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return ds;
        }

        /// <summary>
        /// Hàm lấy về tất cả dữ liệu có sử dụng tham số
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <returns></returns>
        protected static DataSet SelectAllWithParameter(string strStoreName, string[] arrParamName, object[] arrParamValue)
        {
            DataSet ds = new DataSet();
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    ds = objConn.Connection.runDynamicSqlQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure);
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        ds.DataSetName = "Exception:" + ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        ds.DataSetName = "Exception:" + ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return ds;
        }

        /// <summary>
        /// Hàm này lấy tất cả các field dữ liệu của một ROW nào đó
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <param name="strPrimaryKey">Primary Key Value</param>
        /// <returns>DataSet</returns>
        protected static string SelectValue(string strStoreName, string[] arrParamName, object[] arrParamValue)
        {
            IDataReader dr;
            string strReturn = false.ToString();
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    dr = objConn.Connection.runDynamicSqlQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, CommandBehavior.CloseConnection);
                    if (dr.Read())
                        strReturn = dr.GetValue(0).ToString();
                    else
                        strReturn = "";
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        strReturn = ex.Message;
                }
                finally
                {
                    objConn.Close();
                }

            }
            return strReturn;
        }

        #endregion

        #region Update Procedure

        /// <summary>
        /// Hàm này cập nhật các giá trị của 1 ROW thông qua các tham số fieldname và fieldvalue, với tham số đầu tiên là khóa chính của TABLE
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <param name="arrParamName">Array of Parameters</param>
        /// <param name="arrParamValue">Array of Values</param>
        /// <returns></returns>
        protected static string Update(string strStoreName, string[] arrParamName, object[] arrParamValue)
        {
            string strReturn = "0";
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure);
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        strReturn = ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }
        /// <summary>
        /// Hàm này cập nhật các giá trị của 1 ROW thông qua các tham số fieldname và fieldvalue, với tham số đầu tiên là khóa chính của TABLE.
        /// Hàm sử dụng Transaction trong đối tượng Connection đã được tạo trước để thực thi câu lệnh
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <param name="arrParamName">Array of Parameters</param>
        /// <param name="arrParamValue">Array of Values</param>
        /// <param name="objConn"></param>
        /// <returns></returns>
        protected static string Update(string strStoreName, string[] arrParamName, object[] arrParamValue, DataClass objConn)
        {
            string strReturn = "0";
            try
            {
                objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, objConn.Transaction);
            }
            catch (Exception ex)
            {
                if (ex.GetType().Name == typeof(SqlException).Name)
                    strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                else
                    strReturn = ex.Message;
            }
            return strReturn;
        }

        /// <summary>
        /// Hàm này sử dụng Transaction để Update 2 Store Procedure
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <param name="strStoreName2"></param>
        /// <param name="arrParamName2"></param>
        /// <param name="arrParamValue2"></param>
        /// <returns></returns>
        protected static string Update(string strStoreName, string[] arrParamName, object[] arrParamValue, string strStoreName2, string[] arrParamName2, object[] arrParamValue2)
        {
            string strReturn = "0";

            using (DataClass objConn = new DataClass())
            {
                objConn.Open();
                IDbTransaction trans = objConn.BeginTransaction();
                try
                {
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, trans);
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName2, arrParamName2, arrParamValue2, CommandType.StoredProcedure, trans);
                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        strReturn = ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }
        /// <summary>
        /// Hàm này sử dụng Transaction trong đối tượng Connection đã được tạo trước để thực thi 2 câu lệnh Update
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <param name="strStoreName2"></param>
        /// <param name="arrParamName2"></param>
        /// <param name="arrParamValue2"></param>
        /// <returns></returns>
        protected static string Update(string strStoreName, string[] arrParamName, object[] arrParamValue, string strStoreName2, string[] arrParamName2, object[] arrParamValue2, DataClass objConn)
        {
            string strReturn = "0";
            try
            {
                objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, objConn.Transaction);
                objConn.Connection.runDynamicSqlNoQuery(strStoreName2, arrParamName2, arrParamValue2, CommandType.StoredProcedure, objConn.Transaction);
            }
            catch (Exception ex)
            {
                if (ex.GetType().Name == typeof(SqlException).Name)
                    strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                else
                    strReturn = ex.Message;
            }
            return strReturn;
        }

        /// <summary>
        /// Hàm này sử dụng Transaction để Update 3 Store Procedure
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <param name="strStoreName2"></param>
        /// <param name="arrParamName2"></param>
        /// <param name="arrParamValue2"></param>
        /// <param name="strStoreName3"></param>
        /// <param name="arrParamName3"></param>
        /// <param name="arrParamValue3"></param>
        /// <returns></returns>
        protected static string Update(string strStoreName, string[] arrParamName, object[] arrParamValue, string strStoreName2, string[] arrParamName2, object[] arrParamValue2, string strStoreName3, string[] arrParamName3, object[] arrParamValue3)
        {
            string strReturn = "0";
            using (DataClass objConn = new DataClass())
            {
                objConn.Open();
                IDbTransaction trans = objConn.BeginTransaction();
                try
                {
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, trans);
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName2, arrParamName2, arrParamValue2, CommandType.StoredProcedure, trans);
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName3, arrParamName3, arrParamValue3, CommandType.StoredProcedure, trans);
                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        strReturn = ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }
        /// <summary>
        /// Hàm này sử dụng Transaction trong đối tượng Connection đã được tạo trước để thực thi 3 câu lệnh Update
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <param name="strStoreName2"></param>
        /// <param name="arrParamName2"></param>
        /// <param name="arrParamValue2"></param>
        /// <param name="strStoreName3"></param>
        /// <param name="arrParamName3"></param>
        /// <param name="arrParamValue3"></param>
        /// <param name="objConn"></param>
        /// <returns></returns>
        protected static string Update(string strStoreName, string[] arrParamName, object[] arrParamValue, string strStoreName2, string[] arrParamName2, object[] arrParamValue2, string strStoreName3, string[] arrParamName3, object[] arrParamValue3, DataClass objConn)
        {
            string strReturn = "0";
            try
            {
                objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, objConn.Transaction);
                objConn.Connection.runDynamicSqlNoQuery(strStoreName2, arrParamName2, arrParamValue2, CommandType.StoredProcedure, objConn.Transaction);
                objConn.Connection.runDynamicSqlNoQuery(strStoreName3, arrParamName3, arrParamValue3, CommandType.StoredProcedure, objConn.Transaction);
            }
            catch (Exception ex)
            {
                if (ex.GetType().Name == typeof(SqlException).Name)
                    strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                else
                    strReturn = ex.Message;
            }
            return strReturn;
        }

        /// <summary>
        /// Hàm này sử dụng Transaction để Update 4 Store Procedure
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <param name="strStoreName2"></param>
        /// <param name="arrParamName2"></param>
        /// <param name="arrParamValue2"></param>
        /// <param name="strStoreName3"></param>
        /// <param name="arrParamName3"></param>
        /// <param name="arrParamValue3"></param>
        /// <param name="strStoreName4"></param>
        /// <param name="arrParamName4"></param>
        /// <param name="arrParamValue4"></param>
        /// <returns></returns>
        protected static string Update(string strStoreName, string[] arrParamName, object[] arrParamValue, string strStoreName2, string[] arrParamName2, object[] arrParamValue2, string strStoreName3, string[] arrParamName3, object[] arrParamValue3, string strStoreName4, string[] arrParamName4, object[] arrParamValue4)
        {
            string strReturn = "0";
            using (DataClass objConn = new DataClass())
            {
                objConn.Open();
                IDbTransaction trans = objConn.BeginTransaction();
                try
                {
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, trans);
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName2, arrParamName2, arrParamValue2, CommandType.StoredProcedure, trans);
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName3, arrParamName3, arrParamValue3, CommandType.StoredProcedure, trans);
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName4, arrParamName4, arrParamValue4, CommandType.StoredProcedure, trans);
                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        strReturn = ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }
        /// <summary>
        /// Hàm này sử dụng Transaction trong đối tượng Connection đã được tạo trước để thực thi 4 câu lệnh Update
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <param name="strStoreName2"></param>
        /// <param name="arrParamName2"></param>
        /// <param name="arrParamValue2"></param>
        /// <param name="strStoreName3"></param>
        /// <param name="arrParamName3"></param>
        /// <param name="arrParamValue3"></param>
        /// <param name="strStoreName4"></param>
        /// <param name="arrParamName4"></param>
        /// <param name="arrParamValue4"></param>
        /// <param name="objConn"></param>
        /// <returns></returns>
        protected static string Update(string strStoreName, string[] arrParamName, object[] arrParamValue, string strStoreName2, string[] arrParamName2, object[] arrParamValue2, string strStoreName3, string[] arrParamName3, object[] arrParamValue3, string strStoreName4, string[] arrParamName4, object[] arrParamValue4, DataClass objConn)
        {
            string strReturn = "0";
            try
            {
                objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, objConn.Transaction);
                objConn.Connection.runDynamicSqlNoQuery(strStoreName2, arrParamName2, arrParamValue2, CommandType.StoredProcedure, objConn.Transaction);
                objConn.Connection.runDynamicSqlNoQuery(strStoreName3, arrParamName3, arrParamValue3, CommandType.StoredProcedure, objConn.Transaction);
                objConn.Connection.runDynamicSqlNoQuery(strStoreName4, arrParamName4, arrParamValue4, CommandType.StoredProcedure, objConn.Transaction);
            }
            catch (Exception ex)
            {
                if (ex.GetType().Name == typeof(SqlException).Name)
                    strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                else
                    strReturn = ex.Message;
            }
            return strReturn;
        }

        #endregion

        #region Insert Procedure

        /// <summary>
        /// Hàm này thêm một ROW mới vào TABLE thông qua các tham số fieldname và fieldvalue
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <param name="arrParamName">Array of Parameters</param>
        /// <param name="arrParamValue">Array of Values</param>
        /// <returns></returns>
        protected static string Insert(string strStoreName, string[] arrParamName, object[] arrParamValue)
        {
            string strReturn = "0";
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure);
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        strReturn = ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }
        /// <summary>
        /// Hàm này thêm một ROW mới vào TABLE thông qua các tham số fieldname và fieldvalue.
        /// Hàm sử dụng Transaction trong đối tượng Connection đã được tạo trước để thực thi câu lệnh
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <param name="arrParamName">Array of Parameters</param>
        /// <param name="arrParamValue">Array of Values</param>
        /// <param name="objConn"></param>
        /// <returns></returns>
        protected static string Insert(string strStoreName, string[] arrParamName, object[] arrParamValue, DataClass objConn)
        {
            string strReturn = "0";
            try
            {
                objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, objConn.Transaction);
            }
            catch (Exception ex)
            {
                if (ex.GetType().Name == typeof(SqlException).Name)
                    strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                else
                    strReturn = ex.Message;
            }
            return strReturn;
        }

        /// <summary>
        /// Hàm này sử dụng Transaction để thực thi 2 câu lệnh Insert
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <param name="strStoreName2"></param>
        /// <param name="arrParamName2"></param>
        /// <param name="arrParamValue2"></param>
        /// <returns></returns>
        protected static string Insert(string strStoreName, string[] arrParamName, object[] arrParamValue, string strStoreName2, string[] arrParamName2, object[] arrParamValue2)
        {
            string strReturn = "0";
            using (DataClass objConn = new DataClass())
            {
                objConn.Open();
                IDbTransaction trans = objConn.BeginTransaction();
                try
                {
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, trans);
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName2, arrParamName2, arrParamValue2, CommandType.StoredProcedure, trans);
                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        strReturn = ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }
        /// <summary>
        /// Hàm này sử dụng Transaction trong đối tượng Connection đã được tạo trước để thực thi 2 câu lệnh Insert
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <param name="strStoreName2"></param>
        /// <param name="arrParamName2"></param>
        /// <param name="arrParamValue2"></param>
        /// <param name="objConn"></param>
        /// <returns></returns>
        protected static string Insert(string strStoreName, string[] arrParamName, object[] arrParamValue, string strStoreName2, string[] arrParamName2, object[] arrParamValue2, DataClass objConn)
        {
            string strReturn = "0";
            try
            {
                objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, objConn.Transaction);
                objConn.Connection.runDynamicSqlNoQuery(strStoreName2, arrParamName2, arrParamValue2, CommandType.StoredProcedure, objConn.Transaction);
            }
            catch (Exception ex)
            {
                if (ex.GetType().Name == typeof(SqlException).Name)
                    strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                else
                    strReturn = ex.Message;
            }
            return strReturn;
        }

        /// <summary>
        /// Hàm này sử dụng Transaction để thực thi 3 câu lệnh Insert
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <param name="strStoreName2"></param>
        /// <param name="arrParamName2"></param>
        /// <param name="arrParamValue2"></param>
        /// <param name="strStoreName3"></param>
        /// <param name="arrParamName3"></param>
        /// <param name="arrParamValue3"></param>
        /// <returns></returns>
        protected static string Insert(string strStoreName, string[] arrParamName, object[] arrParamValue, string strStoreName2, string[] arrParamName2, object[] arrParamValue2, string strStoreName3, string[] arrParamName3, object[] arrParamValue3)
        {
            string strReturn = "0";
            using (DataClass objConn = new DataClass())
            {
                objConn.Open();
                IDbTransaction trans = objConn.BeginTransaction();
                try
                {
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, trans);
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName2, arrParamName2, arrParamValue2, CommandType.StoredProcedure, trans);
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName3, arrParamName3, arrParamValue3, CommandType.StoredProcedure, trans);
                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        strReturn = ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }
        /// <summary>
        /// Hàm này sử dụng Transaction trong đối tượng Connection đã được tạo trước để thực thi 3 câu lệnh Insert
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <param name="strStoreName2"></param>
        /// <param name="arrParamName2"></param>
        /// <param name="arrParamValue2"></param>
        /// <param name="strStoreName3"></param>
        /// <param name="arrParamName3"></param>
        /// <param name="arrParamValue3"></param>
        /// <param name="objConn"></param>
        /// <returns></returns>
        protected static string Insert(string strStoreName, string[] arrParamName, object[] arrParamValue, string strStoreName2, string[] arrParamName2, object[] arrParamValue2, string strStoreName3, string[] arrParamName3, object[] arrParamValue3, DataClass objConn)
        {
            string strReturn = "0";
            try
            {
                objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, objConn.Transaction);
                objConn.Connection.runDynamicSqlNoQuery(strStoreName2, arrParamName2, arrParamValue2, CommandType.StoredProcedure, objConn.Transaction);
                objConn.Connection.runDynamicSqlNoQuery(strStoreName3, arrParamName3, arrParamValue3, CommandType.StoredProcedure, objConn.Transaction);
            }
            catch (Exception ex)
            {
                if (ex.GetType().Name == typeof(SqlException).Name)
                    strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                else
                    strReturn = ex.Message;
            }
            return strReturn;
        }

        /// <summary>
        /// Hàm này sử dụng Transaction để thực thi 4 câu lệnh Insert
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <param name="strStoreName2"></param>
        /// <param name="arrParamName2"></param>
        /// <param name="arrParamValue2"></param>
        /// <param name="strStoreName3"></param>
        /// <param name="arrParamName3"></param>
        /// <param name="arrParamValue3"></param>
        /// <param name="strStoreName4"></param>
        /// <param name="arrParamName4"></param>
        /// <param name="arrParamValue4"></param>
        /// <returns></returns>
        protected static string Insert(string strStoreName, string[] arrParamName, object[] arrParamValue, string strStoreName2, string[] arrParamName2, object[] arrParamValue2, string strStoreName3, string[] arrParamName3, object[] arrParamValue3, string strStoreName4, string[] arrParamName4, object[] arrParamValue4)
        {
            string strReturn = "0";
            using (DataClass objConn = new DataClass())
            {
                objConn.Open();
                IDbTransaction trans = objConn.BeginTransaction();
                try
                {
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, trans);
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName2, arrParamName2, arrParamValue2, CommandType.StoredProcedure, trans);
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName3, arrParamName3, arrParamValue3, CommandType.StoredProcedure, trans);
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName4, arrParamName4, arrParamValue4, CommandType.StoredProcedure, trans);
                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        strReturn = ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }
        /// <summary>
        /// Hàm này sử dụng Transaction trong đối tượng Connection đã được tạo trước để thực thi 4 câu lệnh Insert
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <param name="strStoreName2"></param>
        /// <param name="arrParamName2"></param>
        /// <param name="arrParamValue2"></param>
        /// <param name="strStoreName3"></param>
        /// <param name="arrParamName3"></param>
        /// <param name="arrParamValue3"></param>
        /// <param name="strStoreName4"></param>
        /// <param name="arrParamName4"></param>
        /// <param name="arrParamValue4"></param>
        /// <param name="objConn"></param>
        /// <returns></returns>
        protected static string Insert(string strStoreName, string[] arrParamName, object[] arrParamValue, string strStoreName2, string[] arrParamName2, object[] arrParamValue2, string strStoreName3, string[] arrParamName3, object[] arrParamValue3, string strStoreName4, string[] arrParamName4, object[] arrParamValue4, DataClass objConn)
        {
            string strReturn = "0";
            try
            {
                objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, objConn.Transaction);
                objConn.Connection.runDynamicSqlNoQuery(strStoreName2, arrParamName2, arrParamValue2, CommandType.StoredProcedure, objConn.Transaction);
                objConn.Connection.runDynamicSqlNoQuery(strStoreName3, arrParamName3, arrParamValue3, CommandType.StoredProcedure, objConn.Transaction);
                objConn.Connection.runDynamicSqlNoQuery(strStoreName4, arrParamName4, arrParamValue4, CommandType.StoredProcedure, objConn.Transaction);
            }
            catch (Exception ex)
            {
                if (ex.GetType().Name == typeof(SqlException).Name)
                    strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                else
                    strReturn = ex.Message;
            }
            return strReturn;
        }

        #endregion

        #region Delete Procedure

        /// <summary>
        /// Hàm này xóa đi một ROW trong một TABLE thông qua khóa chính
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <param name="strPrimaryKey">Primary Key Value</param>
        /// <returns></returns>
        protected static string Delete(string strStoreName, string strPrimaryKeyValue)
        {
            string strReturn = "0";
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName, new string[] { PARAM_PRIMARY_KEY }, new object[] { strPrimaryKeyValue }, CommandType.StoredProcedure);
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        strReturn = ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }
        /// <summary>
        /// Hàm này xóa đi một ROW trong một TABLE thông qua khóa chính.
        /// Hàm sử dụng Transaction trong đối tượng Connection đã được tạo trước để thực thi câu lệnh
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <param name="strPrimaryKey">Primary Key Value</param>
        /// <param name="objConn"></param>
        /// <returns></returns>
        protected static string Delete(string strStoreName, string strPrimaryKeyValue, DataClass objConn)
        {
            string strReturn = "0";
            try
            {
                objConn.Connection.runDynamicSqlNoQuery(strStoreName, new string[] { PARAM_PRIMARY_KEY }, new object[] { strPrimaryKeyValue }, CommandType.StoredProcedure, objConn.Transaction);
            }
            catch (Exception ex)
            {
                if (ex.GetType().Name == typeof(SqlException).Name)
                    strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                else
                    strReturn = ex.Message;
            }
            return strReturn;
        }

        /// <summary>
        /// Hàm này xóa đi một ROW trong một TABLE thông qua mảng tham số
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <param name="arrParamName">Array of Parameters</param>
        /// <param name="arrParamValue">Array of Values</param>
        /// <returns></returns>
        protected static string Delete(string strStoreName, string[] arrParamName, object[] arrParamValue)
        {
            string strReturn = "0";
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure);
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        strReturn = ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }
        /// <summary>
        /// Hàm này xóa đi một ROW trong một TABLE thông qua mảng tham số.
        /// Hàm sử dụng Transaction trong đối tượng Connection đã được tạo trước để thực thi câu lệnh
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <param name="arrParamName">Array of Parameters</param>
        /// <param name="arrParamValue">Array of Values</param>
        /// <param name="objConn"></param>
        /// <returns></returns>
        protected static string Delete(string strStoreName, string[] arrParamName, object[] arrParamValue, DataClass objConn)
        {
            string strReturn = "0";
            try
            {
                objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, objConn.Transaction);
            }
            catch (Exception ex)
            {
                if (ex.GetType().Name == typeof(SqlException).Name)
                    strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                else
                    strReturn = ex.Message;
            }
            return strReturn;
        }

        #endregion

        #region CheckIsExist Procedure

        /// <summary>
        /// Hàm này kiểm tra sự tồn tại của một ROW nào đó thông qua khóa chính
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <param name="strPrimaryKey">Primary Key Value</param>
        /// <returns>bool</returns>
        protected static string CheckIsExist(string strStoreName, string strPrimaryKeyValue)
        {
            IDataReader dr;
            string strReturn = false.ToString();
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    dr = objConn.Connection.runDynamicSqlQuery(strStoreName, new string[] { PARAM_PRIMARY_KEY }, new object[] { strPrimaryKeyValue }, CommandType.StoredProcedure, CommandBehavior.CloseConnection);
                    if (dr.Read())
                        strReturn = true.ToString();
                    else
                        strReturn = false.ToString();
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        strReturn = ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }

        /// <summary>
        /// Hàm này kiểm tra sự tồn tại của một ROW nào đó thông qua khóa chính
        /// </summary>
        /// <param name="strStoreName">Store Procrdure Name</param>
        /// <param name="strPrimaryKey">Primary Key Value</param>
        /// <returns></returns>
        protected static string CheckIsExist(string strStoreName, string[] arrParamName, object[] arrParamValue)
        {
            IDataReader dr;
            string strReturn = false.ToString();
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    dr = objConn.Connection.runDynamicSqlQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure, CommandBehavior.CloseConnection);
                    if (dr.Read())
                        strReturn = true.ToString();
                    else
                        strReturn = false.ToString();
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server;
                    else
                        strReturn = ex.Message;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }

        #endregion

        #endregion

        #region General Procedure
        /// <summary>
        /// Hàm này thực thi một câu lệnh và trả kết quả về dưới dạng một DataSet
        /// </summary>
        /// <param name="strQuery"></param>
        /// <returns></returns>
        protected static DataSet ExecuteSQLStringQuery(string strQuery)
        {
            DataSet ds = new DataSet();
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    ds = objConn.Connection.runSQLQuery(strQuery, CommandType.Text);
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        ds.DataSetName = "Exception:" + ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server + "@" + ((SqlException)ex).StackTrace;
                    else
                        ds.DataSetName = "Exception:" + ex.Message + "@" + ex.StackTrace;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return ds;
        }
        /// <summary>
        /// Hàm này thực thi một câu lệnh có tham số và trả kết quả về dưới dạng một DataSet
        /// </summary>
        /// <param name="strQuery"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <returns></returns>
        protected static DataSet ExecuteSQLStringQuery(string strQuery, string[] arrParamName, object[] arrParamValue)
        {
            DataSet ds = new DataSet();
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    ds = objConn.Connection.runDynamicSqlQuery(strQuery, arrParamName, arrParamValue, CommandType.Text);
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        ds.DataSetName = "Exception:" + ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server + "@" + ((SqlException)ex).StackTrace;
                    else
                        ds.DataSetName = "Exception:" + ex.Message + " @ " + ex.StackTrace;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return ds;
        }

        /// <summary>
        /// Hàm này thực thi một câu lệnh có tham số và trả kết quả về dưới dạng một DataSet
        /// </summary>
        /// <param name="strQuery"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <returns></returns>
        protected static string ExecuteNonQuery(string strStoreName)
        {
            string strReturn = "0";
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    strReturn = objConn.Connection.runSQLNoQuery(strStoreName, CommandType.StoredProcedure).ToString();
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = "Exception:" + ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server + "@" + ((SqlException)ex).StackTrace;
                    else
                        strReturn = "Exception:" + ex.Message + " @ " + ex.StackTrace;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }

        /// <summary>
        /// Hàm này thực thi một câu lệnh có tham số và trả kết quả về dưới dạng một DataSet
        /// </summary>
        /// <param name="strQuery"></param>
        /// <param name="arrParamName"></param>
        /// <param name="arrParamValue"></param>
        /// <returns></returns>
        protected static string ExecuteNonQuery(string strStoreName, string[] arrParamName, object[] arrParamValue)
        {
            string strReturn = "0";
            using (DataClass objConn = new DataClass())
            {
                try
                {
                    objConn.Open();
                    strReturn = objConn.Connection.runDynamicSqlNoQuery(strStoreName, arrParamName, arrParamValue, CommandType.StoredProcedure).ToString();
                }
                catch (Exception ex)
                {
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = "Exception:" + ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server + "@" + ((SqlException)ex).StackTrace;
                    else
                        strReturn = "Exception:" + ex.Message + " @ " + ex.StackTrace;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }

        /// <summary>
        /// Hàm này thực thi một danh sách các store procedure với dữ liệu tương ứng là các tables trong DataSet.
        /// Mỗi store procedure có các tham số là tên các Column và giá trị của column đó. Số tham số trong store và số column phải tương đương
        /// </summary>
        /// <param name="strStoreNames"></param>
        /// <param name="objDataSetParameter"></param>
        /// <returns></returns>
        protected static string ExecuteNonQuery(string[] strStoreNames, System.Data.DataSet objDataSetParameter)
        {
            string strReturn = "0";
            using (DataClass objConn = new DataClass())
            {
                objConn.Open();
                IDbTransaction trans = objConn.BeginTransaction();
                try
                {
                    for (int idxTable = 0; idxTable < objDataSetParameter.Tables.Count; idxTable++)
                    {
                        string[] strParamNames = new string[objDataSetParameter.Tables[idxTable].Columns.Count];
                        object[] objParamValues = new object[objDataSetParameter.Tables[idxTable].Columns.Count];
                        for (int idxRows = 0; idxRows < objDataSetParameter.Tables[idxTable].Rows.Count; idxRows++)
                        {
                            for (int idxColumn = 0; idxColumn < objDataSetParameter.Tables[idxTable].Columns.Count; idxColumn++)
                            {
                                strParamNames[idxColumn] = objDataSetParameter.Tables[idxTable].Columns[idxColumn].ColumnName;
                                objParamValues[idxColumn] = objDataSetParameter.Tables[idxTable].Rows[idxRows][idxColumn];
                            }
                            objConn.Connection.runDynamicSqlNoQuery(strStoreNames[idxTable], strParamNames, objParamValues, CommandType.StoredProcedure, trans);
                        }
                    }
                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server + "@" + ((SqlException)ex).StackTrace;
                    else
                        strReturn = ex.Message + "@" + ex.StackTrace;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }
        /// <summary>
        /// Hàm này thực thi một danh sách các store procedure với dữ liệu tương ứng là các tables trong DataSet.
        /// Mỗi store procedure có các tham số là tên các Column và giá trị của column đó. Số tham số trong store và số column phải tương đương
        /// Hàm sử dụng Transaction trong đối tượng Connection đã được tạo trước để thực thi câu lệnh
        /// </summary>
        /// <param name="strStoreNames"></param>
        /// <param name="objDataSetParameter"></param>
        /// <param name="objConn"></param>
        /// <returns></returns>
        protected static string ExecuteNonQuery(string[] strStoreNames, System.Data.DataSet objDataSetParameter, DataClass objConn)
        {
            string strReturn = "0";
            try
            {
                for (int idxTable = 0; idxTable < objDataSetParameter.Tables.Count; idxTable++)
                {
                    string[] strParamNames = new string[objDataSetParameter.Tables[idxTable].Columns.Count];
                    object[] objParamValues = new object[objDataSetParameter.Tables[idxTable].Columns.Count];
                    for (int idxRows = 0; idxRows < objDataSetParameter.Tables[idxTable].Rows.Count; idxRows++)
                    {
                        for (int idxColumn = 0; idxColumn < objDataSetParameter.Tables[idxTable].Columns.Count; idxColumn++)
                        {
                            strParamNames[idxColumn] = objDataSetParameter.Tables[idxTable].Columns[idxColumn].ColumnName;
                            objParamValues[idxColumn] = objDataSetParameter.Tables[idxTable].Rows[idxRows][idxColumn];
                        }
                        objConn.Connection.runDynamicSqlNoQuery(strStoreNames[idxTable], strParamNames, objParamValues, CommandType.StoredProcedure, objConn.Transaction);
                    }
                }
            }
            catch (Exception ex)
            {
                if (ex.GetType().Name == typeof(SqlException).Name)
                    strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server + "@" + ((SqlException)ex).StackTrace;
                else
                    strReturn = ex.Message + "@" + ex.StackTrace;
            }
            return strReturn;
        }

        /// <summary>
        /// Hàm này thực thi một store procedure với dữ liệu tương ứng trong tham số kiểu datatable.
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="strParamNames"></param>
        /// <param name="objDataTableValue"></param>
        /// <returns></returns>
        protected static string ExecuteMultiNonQuery(string strStoreName, string[] strParamNames, System.Data.DataTable objDataTableValue)
        {
            string strReturn = "0";
            using (DataClass objConn = new DataClass())
            {
                objConn.Open();
                IDbTransaction trans = objConn.BeginTransaction();
                try
                {
                    for (int idxRows = 0; idxRows < objDataTableValue.Rows.Count; idxRows++)
                    {
                        object[] objParamValues = new object[objDataTableValue.Columns.Count];
                        objParamValues = objDataTableValue.Rows[idxRows].ItemArray;
                        objConn.Connection.runDynamicSqlNoQuery(strStoreName, strParamNames, objParamValues, CommandType.StoredProcedure, trans);
                    }
                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server + "@" + ((SqlException)ex).StackTrace;
                    else
                        strReturn = ex.Message + "@" + ex.StackTrace;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }
        /// <summary>
        /// Hàm này thực thi một store procedure với dữ liệu tương ứng trong tham số kiểu datatable.
        /// Hàm sử dụng Transaction trong đối tượng Connection đã được tạo trước để thực thi câu lệnh
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="strParamNames"></param>
        /// <param name="objDataTableValue"></param>
        /// <param name="objConn"></param>
        /// <returns></returns>
        protected static string ExecuteMultiNonQuery(string strStoreName, string[] strParamNames, System.Data.DataTable objDataTableValue, DataClass objConn)
        {
            string strReturn = "0";
            try
            {
                for (int idxRows = 0; idxRows < objDataTableValue.Rows.Count; idxRows++)
                {
                    object[] objParamValues = new object[objDataTableValue.Columns.Count];
                    objParamValues = objDataTableValue.Rows[idxRows].ItemArray;
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName, strParamNames, objParamValues, CommandType.StoredProcedure, objConn.Transaction);
                }
            }
            catch (Exception ex)
            {
                if (ex.GetType().Name == typeof(SqlException).Name)
                    strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server + "@" + ((SqlException)ex).StackTrace;
                else
                    strReturn = ex.Message + "@" + ex.StackTrace;
            }
            return strReturn;
        }

        /// <summary>
        /// Hàm này thực thi một store procedure với dữ liệu tương ứng trong tham số kiểu datatable cộng với các tham số rời.
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="strParamName"></param>
        /// <param name="objDataTableValue"></param>
        /// <param name="strParamName2"></param>
        /// <param name="objParamValue2"></param>
        /// <returns></returns>
        protected static string ExecuteMultiNonQuery(string strStoreName, string[] strParamName, System.Data.DataTable objDataTableValue, string[] strParamName2, object[] objParamValue2)
        {
            string strReturn = "0";
            using (DataClass objConn = new DataClass())
            {
                objConn.Open();
                IDbTransaction trans = objConn.BeginTransaction();
                try
                {
                    for (int idxRows = 0; idxRows < objDataTableValue.Rows.Count; idxRows++)
                    {
                        string[] strParaNames = new string[objDataTableValue.Columns.Count + strParamName2.Length];
                        object[] objParaValues = new object[objDataTableValue.Columns.Count + strParamName2.Length];
                        for (int i = 0; i < strParamName2.Length; i++)
                        {
                            strParaNames[i] = strParamName2[i];
                            objParaValues[i] = objParamValue2[i];
                        }
                        for (int idxColumn = 0; idxColumn < objDataTableValue.Columns.Count; idxColumn++)
                        {
                            strParaNames[idxColumn + strParamName2.Length] = strParamName[idxColumn];
                            objParaValues[idxColumn + strParamName2.Length] = objDataTableValue.Rows[idxRows][idxColumn];
                        }
                        objConn.Connection.runDynamicSqlNoQuery(strStoreName, strParaNames, objParaValues, CommandType.StoredProcedure, trans);
                    }
                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    if (ex.GetType().Name == typeof(SqlException).Name)
                        strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server + "@" + ((SqlException)ex).StackTrace;
                    else
                        strReturn = ex.Message + "@" + ex.StackTrace;
                }
                finally
                {
                    objConn.Close();
                }
            }
            return strReturn;
        }
        /// <summary>
        /// Hàm này thực thi một store procedure với dữ liệu tương ứng trong tham số kiểu datatable cộng với các tham số rời.
        /// Hàm sử dụng Transaction trong đối tượng Connection đã được tạo trước để thực thi câu lệnh
        /// </summary>
        /// <param name="strStoreName"></param>
        /// <param name="strParamName"></param>
        /// <param name="objDataTableValue"></param>
        /// <param name="strParamName2"></param>
        /// <param name="objParamValue2"></param>
        /// <param name="objConn"></param>
        /// <returns></returns>
        protected static string ExecuteMultiNonQuery(string strStoreName, string[] strParamName, System.Data.DataTable objDataTableValue, string[] strParamName2, object[] objParamValue2, DataClass objConn)
        {
            string strReturn = "0";
            try
            {
                for (int idxRows = 0; idxRows < objDataTableValue.Rows.Count; idxRows++)
                {
                    string[] strParaNames = new string[objDataTableValue.Columns.Count + strParamName2.Length];
                    object[] objParaValues = new object[objDataTableValue.Columns.Count + strParamName2.Length];
                    for (int i = 0; i < strParamName2.Length; i++)
                    {
                        strParaNames[i] = strParamName2[i];
                        objParaValues[i] = objParamValue2[i];
                    }
                    for (int idxColumn = 0; idxColumn < objDataTableValue.Columns.Count; idxColumn++)
                    {
                        strParaNames[idxColumn + strParamName2.Length] = strParamName[idxColumn];
                        objParaValues[idxColumn + strParamName2.Length] = objDataTableValue.Rows[idxRows][idxColumn];
                    }
                    objConn.Connection.runDynamicSqlNoQuery(strStoreName, strParaNames, objParaValues, CommandType.StoredProcedure, objConn.Transaction);
                }
            }
            catch (Exception ex)
            {
                if (ex.GetType().Name == typeof(SqlException).Name)
                    strReturn = ((SqlException)ex).Number + "@" + ((SqlException)ex).Procedure + "@" + ((SqlException)ex).Server + "@" + ((SqlException)ex).StackTrace;
                else
                    strReturn = ex.Message + "@" + ex.StackTrace;
            }
            return strReturn;
        }

        #endregion

        //public static object[] Execute(string strMethod, object[] args)
        //{
        //    object[] results = Invoke(strMethod, args);
        //    return results;
        //}
    }
}
